/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Calculos;

import java.util.ArrayList;
import org.jfree.chart.ChartPanel;

/**
 *
 * @author Beto
 */
public class CalcularDiagrama {


    private CalculaConcentrada cargaConcentrada;
    private CalculaDistribuida cargaDistribuida;
    private EngastadaInvertidaCentrada engasInvertCentrada;
    private EngastadaInvertidaDistribuida engasInvertDistribuida;
    private CalculaCargaMomento cargaMomento;
    private EngastadaCentrada engCentrada;
    private EngastadaDistribuida engDistribuida;
    private EngastadacargaMomento engCargaMomento;
    private double MfletorResultante[], FcortanteResultante[],x[], DeformadaResultante[];

    private double tamanhoViga;//tamanho da viga em metros
    private double xViga;//inicio da viga em metros
    private double forcaC;//intensidade da carga concentrada em N
    private double forcaD;//intensidade da carga distribuida em N
    private double forcaM;//intensidade da carga momento
    private double xConcentrada;//localizacao da carga concentrada em metros
    private double xDistribuida;//localizacao da carga distribuida em metros
    private double tamanhoD;//tamanho da carga distribuida em metros
    private double xMomento;//localização da carga momento
    private boolean distribuidaAtiva,centradaAtiva,momentoAtiva,fixo,eng,engInvertida;
    private double IY;

    private boolean opcaoGrafico;

    public CalcularDiagrama(double tamanhoViga, double xViga, double forcaC, double forcaD, double xConcentrada,
            double xDistribuida, double tamanhoD,double forcaM,double xMomento, boolean distribuidaAtiva, boolean centradaAtiva,boolean momentoAtiva,
            boolean fixo,boolean eng,boolean engIntertida, boolean opcaoGrafico) {

        this.tamanhoViga = tamanhoViga;
        this.xViga = xViga;
        this.forcaC = forcaC;
        this.forcaD = forcaD;
        this.forcaM=forcaM;
        this.xConcentrada = xConcentrada;
        this.xDistribuida = xDistribuida;
        this.xMomento=xMomento;
        this.tamanhoD = tamanhoD;
        this.distribuidaAtiva = distribuidaAtiva;
        this.centradaAtiva = centradaAtiva;
        this.momentoAtiva=momentoAtiva;
        this.fixo=fixo;
        this.eng=eng;
        this.engInvertida=engIntertida;
        this.opcaoGrafico = opcaoGrafico;
    }

    public CalcularDiagrama(double tamanhoViga, double xViga, double forcaC, double forcaD, double xConcentrada,
            double xDistribuida, double tamanhoD,double forcaM,double xMomento, boolean distribuidaAtiva, boolean centradaAtiva,boolean momentoAtiva,
            boolean fixo,boolean eng,boolean engIntertida, double IY, boolean opcaoGrafico) {

        this.tamanhoViga = tamanhoViga;
        this.xViga = xViga;
        this.forcaC = forcaC;
        this.forcaD = forcaD;
        this.forcaM = forcaM;
        this.xConcentrada = xConcentrada;
        this.xDistribuida = xDistribuida;
        this.tamanhoD = tamanhoD;
        this.xMomento = xMomento;
        this.distribuidaAtiva = distribuidaAtiva;
        this.centradaAtiva = centradaAtiva;
        this.momentoAtiva = momentoAtiva;
        this.fixo = fixo;
        this.eng = eng;
        this.IY = IY;
        this.opcaoGrafico = opcaoGrafico;
    }



  

    



public ChartPanel[] calculaDiagramas(){

    ///////////////////Cargas bi-apoiadas///////////////////////

    if (fixo) {
        //calcula Diagramas para carga distribuida
        cargaDistribuida = new CalculaDistribuida(xViga);
        cargaDistribuida.CalculaCargaDistribuida(forcaD, tamanhoD, tamanhoViga, xDistribuida);
        if(!opcaoGrafico){
            cargaDistribuida.CalculaDeformadaVetor(forcaD, tamanhoD, tamanhoViga, xDistribuida,IY);
        }
        //calcula Diagramas para carga Centrada
        cargaConcentrada = new CalculaConcentrada(xViga);
        cargaConcentrada.CalculaCargaCentrada(forcaC, tamanhoViga, xConcentrada);
        //Deformada
        if(!opcaoGrafico){
            cargaConcentrada.CalculaDeformadaVetor(forcaC, tamanhoViga, xConcentrada, IY);
        }


        //Calcula Diagrama para Carga-Momento
        cargaMomento=new CalculaCargaMomento();
        cargaMomento.CalculaCargaMomento(forcaM, tamanhoViga, xMomento);
        //Deformada
        if(!opcaoGrafico){
            cargaMomento.DeformadaCargaMomento(forcaM, tamanhoViga, xMomento, IY);
        }

    } /////////////////////////////////////////////////////////////////////////////////
    
        //////////////////////Cargas Engastadas///////////////////////////////
    else if (eng) {
        engDistribuida=new EngastadaDistribuida();
        engDistribuida.CalculaCargaDistribuida(forcaD, tamanhoD, tamanhoViga, xDistribuida,IY);
        //Deformada
        if(!opcaoGrafico){
            engDistribuida.CalculaDeformada(forcaD, tamanhoD, tamanhoViga, xDistribuida,IY);
        }

        //////carga centrada
        engCentrada=new EngastadaCentrada();
        engCentrada.CalculaCargaCentrada(forcaC, tamanhoViga, xConcentrada);
        //Deformada
        if(!opcaoGrafico){
            engCentrada.CalculaDeformadaVetor(forcaC, tamanhoViga, xConcentrada, IY);
        }

        engCargaMomento=new EngastadacargaMomento();
        engCargaMomento.calculaCargaMomento(forcaM, tamanhoViga);
        //Deformada
        if(!opcaoGrafico){
            engCargaMomento.CalculaDeformadaVetor(forcaM, tamanhoViga, xMomento, IY);
        }

    }
    else if (engInvertida) {

        engasInvertDistribuida = new EngastadaInvertidaDistribuida(xViga);
        engasInvertDistribuida.CalculaCargaDistribuida(forcaD, tamanhoD, tamanhoViga, xDistribuida);
        //carga Centrada
        engasInvertCentrada = new EngastadaInvertidaCentrada(xViga);
        engasInvertCentrada.CalculaCargaCentrada(forcaC, tamanhoViga, xConcentrada);
    }
    ///////////////////////////////////////////////////////////////////////////

    DiagramaResultante(distribuidaAtiva, centradaAtiva,momentoAtiva);//calcula pontos resultantes dos gráficos
    if(!opcaoGrafico){
        DiagramaResultanteDeformada(distribuidaAtiva, centradaAtiva, momentoAtiva);
    }

    //constroi os gráficos propriamente dito
    ChartPanel diagramas[] = null;
    if (opcaoGrafico) {
        diagramas = new ChartPanel[2];
        Graficos diagramaMfletor = new Graficos("Diagrama Carga Distribuída + Carga Concentrada + Carga-Momento", "Momento Fletor", x, MfletorResultante, true);
        Graficos diagramaEContante = new Graficos("Diagrama Carga Distribuída + Carga Concentrada + Carga-Momento", "Esforço Cortante", x, FcortanteResultante, false);
        diagramas[0] = diagramaMfletor.getChart();
        diagramas[1] = diagramaEContante.getChart();
    }
    else{
        diagramas = new ChartPanel[3];
        Graficos diagramaMfletor = new Graficos("Diagrama Carga Distribuída + Carga Concentrada + Carga-Momento", "Momento Fletor", x, MfletorResultante, true);
        Graficos diagramaEContante = new Graficos("Diagrama Carga Distribuída + Carga Concentrada + Carga-Momento", "Esforço Cortante", x, FcortanteResultante, false);
        Graficos diagramaDeformada = new Graficos("Diagrama Carga Distribuída + Carga Concentrada + Carga-Momento", "Deformada", x, DeformadaResultante, true);
        diagramas[0] = diagramaMfletor.getChart();
        diagramas[1] = diagramaEContante.getChart();
        diagramas[2] = diagramaDeformada.getChart();
    }
    return diagramas;
    
}


    private void DiagramaResultante(boolean distribuidaAtiva, boolean centradaAtiva, boolean momentoAtiva) {

        int tamanhoVetor = 0;
        ArrayList<double[]> cargaDist = null;
        ArrayList<double[]> cargaCent = null;
        ArrayList<double[]> cargaMomen = null;
        if (fixo) {
            tamanhoVetor = cargaDistribuida.getCargaDistribuida().get(0).length;
            cargaDist = cargaDistribuida.getCargaDistribuida();
            cargaCent = cargaConcentrada.getCargaCentrada();
            cargaMomen = cargaMomento.getCargaMomento();
        } else if (eng) {
            tamanhoVetor = engDistribuida.getCargaDistribuida().get(0).length;
            cargaDist = engDistribuida.getCargaDistribuida();
            cargaCent = engCentrada.getCargaCentrada();
            cargaMomen=engCargaMomento.getCargaMomento();


        } else if (engInvertida) {
            tamanhoVetor = engasInvertCentrada.getCargaCentrada().get(0).length;
            cargaDist = engasInvertDistribuida.getCargaDistribuida();
            cargaCent = engasInvertCentrada.getCargaCentrada();
        }
        MfletorResultante = new double[tamanhoVetor];
        FcortanteResultante = new double[tamanhoVetor];
        x = new double[tamanhoVetor];// o x é o mesmo pros 2 diagramas
        for (int i = 0; i < tamanhoVetor; i++) {
            if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                MfletorResultante[i] = cargaDist.get(1)[i] + cargaCent.get(1)[i] + cargaMomen.get(1)[i];
                FcortanteResultante[i] = cargaDist.get(3)[i] + cargaCent.get(3)[i] + cargaMomen.get(3)[i];
            }
            else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
                MfletorResultante[i] = cargaDist.get(1)[i] + cargaCent.get(1)[i];
                FcortanteResultante[i] = cargaDist.get(3)[i] + cargaCent.get(3)[i];
            }
             else if (distribuidaAtiva && momentoAtiva) {
                MfletorResultante[i] = cargaDist.get(1)[i] + cargaMomen.get(1)[i];
                FcortanteResultante[i] = cargaDist.get(3)[i] + cargaMomen.get(3)[i];
            }
            else if (centradaAtiva && momentoAtiva) {
                MfletorResultante[i] = cargaCent.get(1)[i] + cargaMomen.get(1)[i];
                FcortanteResultante[i] = cargaCent.get(3)[i] + cargaMomen.get(3)[i];
            }
            else if (distribuidaAtiva) {//caso so tenha carga distribuida
                MfletorResultante[i] = cargaDist.get(1)[i];
                FcortanteResultante[i] = cargaDist.get(3)[i];
            }
            else if (centradaAtiva) {//caso só haja carga centrada
                MfletorResultante[i] = cargaCent.get(1)[i];
                FcortanteResultante[i] = cargaCent.get(3)[i];
            }
            else if (momentoAtiva) {//caso só haja carga centrada
                MfletorResultante[i] = cargaMomen.get(1)[i];
                FcortanteResultante[i] = cargaMomen.get(3)[i];
            }


        }
        x = cargaDist.get(0);
    }

    private void DiagramaResultanteDeformada(boolean distribuidaAtiva, boolean centradaAtiva, boolean momentoAtiva) {

        int tamanhoVetor = 0;
        ArrayList<double[]> cargaDist = null;
        ArrayList<double[]> cargaCent = null;
        ArrayList<double[]> cargaMomen = null;
        if (fixo) {
            tamanhoVetor = cargaConcentrada.getDeformada().get(0).length;
            cargaDist = cargaDistribuida.getDeformada();
            cargaCent = cargaConcentrada.getDeformada();
            cargaMomen = cargaMomento.getDeformada();
        }
        else if (eng) {
            tamanhoVetor = engDistribuida.getDeformada().get(0).length;
            cargaDist = engDistribuida.getDeformada();
            cargaCent = engCentrada.getDeformada();
            cargaMomen=engCargaMomento.getDeformada();
        }
        
        DeformadaResultante = new double[tamanhoVetor];
        x = new double[tamanhoVetor];// o x é o mesmo pros 2 diagramas
        int fator = 1;
        for (int i = 0; i < tamanhoVetor; i++) {
            if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                //DeformadaResultante[i] = cargaDist.get(1)[i] + cargaCent.get(1)[i] + cargaMomen.get(1)[i];
                DeformadaResultante[i] = (cargaDist.get(1)[i] + cargaCent.get(1)[i] + cargaMomen.get(1)[i])*fator;
            }
            else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
                //DeformadaResultante[i] = cargaDist.get(1)[i] + cargaCent.get(1)[i];
                DeformadaResultante[i] = (cargaDist.get(1)[i] + cargaCent.get(1)[i])*fator;
            }
             else if (distribuidaAtiva && momentoAtiva) {
                //DeformadaResultante[i] = cargaDist.get(1)[i] + cargaMomen.get(1)[i];
                 DeformadaResultante[i] = (cargaDist.get(1)[i] + cargaMomen.get(1)[i])*fator;
            }
            else if (centradaAtiva && momentoAtiva) {
                //DeformadaResultante[i] = cargaCent.get(1)[i] + cargaMomen.get(1)[i];
                DeformadaResultante[i] = (cargaCent.get(1)[i] + cargaMomen.get(1)[i])*fator;
            }
            else if (distribuidaAtiva) {//caso so tenha carga distribuida
                //DeformadaResultante[i] = cargaDist.get(1)[i];
                DeformadaResultante[i] = cargaDist.get(1)[i]*fator;
            }
            else if (centradaAtiva) {//caso só haja carga centrada
                //DeformadaResultante[i] = cargaCent.get(1)[i];
                DeformadaResultante[i] = cargaCent.get(1)[i]*fator;
            }
            else if (momentoAtiva) {//caso só haja carga centrada
                //DeformadaResultante[i] = cargaMomen.get(1)[i];
                DeformadaResultante[i] = cargaMomen.get(1)[i]*fator;
            }
        }
        x = cargaCent.get(0);
    }

public double MomentoFletorNoPonto(double x) {
        double resultado = 0.0;

        if(fixo){
        if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaConcentrada.calculaMomentoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    +cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
        else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaConcentrada.calculaMomentoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
        else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado =  cargaConcentrada.calculaMomentoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    + cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }

        else if (distribuidaAtiva) {//caso so tenha carga distribuida
            resultado = cargaDistribuida.calculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida);
        }
        else if (centradaAtiva) {//caso só haja carga centrada
            resultado = cargaConcentrada.calculaMomentoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (momentoAtiva) {//caso só haja carga momento
            resultado = cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
    }
    else if(eng){
         if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCentrada.CalculaFuncaoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    +engCargaMomento.CalculaFletorNoPonto(x, forcaM);
        }
        else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCentrada.CalculaFuncaoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCargaMomento.CalculaFletorNoPonto(x, forcaM);
        }
        else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado =  engCentrada.CalculaFuncaoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    + engCargaMomento.CalculaFletorNoPonto(x, forcaM);
        }

        else if (distribuidaAtiva) {//caso so tenha carga distribuida
            resultado = engDistribuida.CalculaMomentoFletorNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida);
        }
        else if (centradaAtiva) {//caso só haja carga centrada
            resultado = engCentrada.CalculaFuncaoFletorNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (momentoAtiva) {//caso só haja carga momento
            resultado = engCargaMomento.CalculaFletorNoPonto(x, forcaM);
        }

    }
        return resultado;
    }
   
public double EsforcoCortanteNoPonto(double x) {
        double resultado = 0.0;

        if(fixo){
        if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaConcentrada.CalculaEContanteCentradaNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    +cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
        else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaConcentrada.CalculaEContanteCentradaNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = cargaDistribuida.calculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
        else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado =  cargaConcentrada.CalculaEContanteCentradaNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    + cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }

        else if (distribuidaAtiva) {//caso so tenha carga distribuida
            resultado = cargaDistribuida.calculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida);
        }
        else if (centradaAtiva) {//caso só haja carga centrada
            resultado = cargaConcentrada.CalculaEContanteCentradaNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (momentoAtiva) {//caso só haja carga momento
            resultado = cargaMomento.EsforcoCortanteCargaMomentoNoPonto(x, forcaM, tamanhoViga,xMomento);
        }
    }
    else if(eng){
         if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCentrada.CalculaEsforcoCortanteNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    +engCargaMomento.CalculaEsforcoCortanteNoPonto();
        }
        else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCentrada.CalculaEsforcoCortanteNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado = engDistribuida.CalculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida)
                    + engCargaMomento.CalculaEsforcoCortanteNoPonto();
        }
        else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
            resultado =  engCentrada.CalculaEsforcoCortanteNoPonto(x, forcaC, tamanhoViga, xConcentrada)
                    + engCargaMomento.CalculaEsforcoCortanteNoPonto();
        }

        else if (distribuidaAtiva) {//caso so tenha carga distribuida
            resultado = engDistribuida.CalculaEsforcoCortanteNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida);
        }
        else if (centradaAtiva) {//caso só haja carga centrada
            resultado = engCentrada.CalculaEsforcoCortanteNoPonto(x, forcaC, tamanhoViga, xConcentrada);
        }
        else if (momentoAtiva) {//caso só haja carga momento
            resultado = engCargaMomento.CalculaEsforcoCortanteNoPonto();
        }

    }
        return resultado;
    }


    public double DeformadaNoPonto(double x) {
        double resultado = 0.0;

        if (fixo) {
            if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = cargaDistribuida.calculaDeformadaNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + cargaConcentrada.CalculoDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY)
                        + cargaMomento.DeformadaCargaMomentoNoPonto(x, forcaC, tamanhoViga, xMomento, IY);
            } 
            else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = cargaDistribuida.calculaDeformadaNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + cargaConcentrada.CalculoDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY);
            } 
            else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = cargaDistribuida.calculaDeformadaNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + cargaMomento.DeformadaCargaMomentoNoPonto(x, forcaC, tamanhoViga, xMomento, IY);
            } 
            else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = cargaConcentrada.CalculoDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY)
                        + cargaMomento.DeformadaCargaMomentoNoPonto(x, forcaC, tamanhoViga, xMomento, IY);
            } 
            else if (distribuidaAtiva) {//caso so tenha carga distribuida
                resultado =  cargaDistribuida.calculaDeformadaNoPonto(x, forcaD, tamanhoD, tamanhoViga, xDistribuida,IY);
            } 
            else if (centradaAtiva) {//caso só haja carga centrada
                resultado = cargaConcentrada.CalculoDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY);
            } 
            else if (momentoAtiva) {//caso só haja carga momento
                resultado = cargaMomento.DeformadaCargaMomentoNoPonto(x, forcaM, tamanhoViga, xMomento, IY);
            }
        } 
        else if (eng) {
            if (distribuidaAtiva && centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = engDistribuida.CalculaDeformadaNoPonto(x,forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + engCentrada.CalculaDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY)
                        + engCargaMomento.CalculaDeformadaPonto(x, forcaM,tamanhoViga,xMomento,IY);
            } else if (distribuidaAtiva && centradaAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = engDistribuida.CalculaDeformadaNoPonto(x,forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + engCentrada.CalculaDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY);
            } else if (distribuidaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = engDistribuida.CalculaDeformadaNoPonto(x,forcaD, tamanhoD, tamanhoViga, xDistribuida,IY)
                        + engCargaMomento.CalculaDeformadaPonto(x, forcaM,tamanhoViga,xMomento,IY);
            } else if (centradaAtiva && momentoAtiva) {//se existe as duas cargas calcula o diagrama resultante
                resultado = engCentrada.CalculaDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY)
                        + engCargaMomento.CalculaDeformadaPonto(x, forcaM,tamanhoViga,xMomento,IY);
            } else if (distribuidaAtiva) {//caso so tenha carga distribuida
                resultado = engDistribuida.CalculaDeformadaNoPonto(x,forcaD, tamanhoD, tamanhoViga, xDistribuida,IY);
            } else if (centradaAtiva) {//caso só haja carga centrada
                resultado = engCentrada.CalculaDeformadaPonto(x, forcaC, tamanhoViga, xConcentrada,IY);
            } else if (momentoAtiva) {//caso só haja carga momento
                resultado = engCargaMomento.CalculaDeformadaPonto(x, forcaM,tamanhoViga,xMomento,IY);
            }

        }
        int fator=1;
        return resultado*fator;
    }
        



public double getReacaoBiemA(){
     double resultado = 0.0;
        if(centradaAtiva){
            resultado+=cargaConcentrada.getRA();
        }
        if(distribuidaAtiva){
            resultado+=cargaDistribuida.getRA();
        }
     if(momentoAtiva){
            resultado+=cargaMomento.getRA();
        }
        return resultado;
}

public double getReacaoBiemB(){
     double resultado = 0.0;
        if(centradaAtiva){
            resultado+=cargaConcentrada.getRB();
        }
        if(distribuidaAtiva){
            resultado+=cargaDistribuida.getRB();
        }
     if(momentoAtiva){
            resultado+=cargaMomento.getRB();
        }
        return resultado;
}

public double getReacaoApoioEngastado(){
    double resultado = 0.0;
        if(centradaAtiva){
            resultado+=engCentrada.getR();
        }
        if(distribuidaAtiva){
            resultado+=engDistribuida.getR();
        }
     if(momentoAtiva){
           resultado+=engCargaMomento.getR();
        }
        return resultado;
}

    public double[] getMfletorResultante() {
        return MfletorResultante;
    }

    public double[] getFcortanteResultante() {
        return FcortanteResultante;
    }

    public double[] getX() {
        return x;
    }


    private void setDeformadaXFatorConcentrada(ArrayList<double[]> cargaCent){
        ArrayList<double[]> temp = new ArrayList<double[]>();
        double y[] = new double[cargaConcentrada.getDeformada().get(1).length];
        //atribuindo o x
        temp.add(cargaConcentrada.getDeformada().get(0));
        int fator = 1000;
        for(int i = 0; i < cargaConcentrada.getDeformada().get(0).length;i++){
            y[i] = fator*cargaConcentrada.getDeformada().get(1)[i];
        }
        temp.add(y);
        cargaCent = temp;
    }

    public double[] getDeformadaResultante() {
        return DeformadaResultante;
    }
    


    

}
